package com.jz.digital.utils;

import android.os.Bundle;

import androidx.fragment.app.Fragment;

import com.jz.digital.base.BasePresenter;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.List;

/**
 * Created by lyw.
 *
 * @author: lyw
 * @package: com.ido.veryfitpro.util
 * @description: ${TODO}{ 类注释}
 * @date: 2018/7/16 0016
 */

public class ObjectUtil {
    /**
     * 获取传入Class对面里面泛型
     * 得到泛型类P的对象
     * @return Class对象的第一个泛型对象
     */
    public  static <P extends BasePresenter> P getParameterizedType(Class<?> clazz){

            Class<?> c= getParameterizedType(clazz,false);
            try {
                if (c==null){
                    return null;
                }
                return (P)c.newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }

        return null;

    }
    public static Class<?> getParameterizedType(Class<?> clazz, boolean isInterface){
        //返回表示此 Class 所表示的实体类的 直接父类 的 Type。注意，是直接父类
        Type type = clazz.getGenericSuperclass();
        try {
            if (isInterface) {
                type = clazz.getGenericInterfaces()[0];
            }
            // 判断 是否泛型
            if (type instanceof ParameterizedType) {
                // 返回表示此类型实际类型参数的Type对象的数组.
                // 当有多个泛型类时，数组的长度就不是1了
                Type[] ptype = ((ParameterizedType) type).getActualTypeArguments();
//                Class<?> c = (Class) ptype[0];
                Type t = ptype[0];
                if(t instanceof Class) {
                    Class<?> c = (Class) ptype[0];
                    return c;
                }else if(t instanceof ParameterizedType){
                    return (Class)((ParameterizedType) t).getRawType();
                }
//                return c;
            }
        }catch (Exception e){
            e.printStackTrace();
        }

        return null;
    }
    //判断clazz是否是List或者实现了List接口
    public static boolean isList(Class clazz) {
        if(clazz == List.class) {
            return true;
        }
        Class[] interfaces = clazz.getInterfaces();
        if(interfaces==null||interfaces.length==0) {
            return false;
        }
        for(Class<?> c:interfaces) {
            if(c== List.class) {
                return true;
            }
        }
        return false;
    }
    /**
     * 如果是集合
     * @param clazz
     * @param isInterface
     * @return
     */
    public static Class<?> getParameterizedTypeList(Class<?> clazz, boolean isInterface){
        //返回表示此 Class 所表示的实体类的 直接父类 的 Type。注意，是直接父类
        Type type = clazz.getGenericSuperclass();
        try {
            if (isInterface) {
                type = clazz.getGenericInterfaces()[0];
            }
            // 判断 是否泛型
            if (type instanceof ParameterizedType) {
                // 返回表示此类型实际类型参数的Type对象的数组.
                // 当有多个泛型类时，数组的长度就不是1了
                Type[] ptype = ((ParameterizedType) type).getActualTypeArguments();
                Type t = ptype[0];
                if(t instanceof Class) {
                    Class<?> c = (Class) ptype[0];
                    return c;
                }else if(t instanceof ParameterizedType){
                    return (Class)((ParameterizedType) t).getActualTypeArguments()[0];
                }
                return null;
            }
        }catch (Exception e){
            e.printStackTrace();
        }

        return null;
    }
    public static boolean isCollectionEmpty(Collection collection){
        if (collection==null){
            return true;
        }
        return collection.isEmpty();
    }
    public static boolean isArrayEmpty(Object[] collection){
        if (collection==null){
            return true;
        }
        return collection.length==0;
    }
    /**
     * 生成一个Fragment实例
     * @param clz Fragemnt 的Class对象
     * @param args 携带的参数
     * @param <T>
     * @return
     */
    public static <T extends Fragment>T newInstance(Class clz,
                                                    Bundle args) {
        T fragment = null;
        try {
            fragment = (T)clz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        if (fragment != null) {
            fragment.setArguments(args);
        }
        return fragment;
    }
}
